Image Compression and Lossless Reconstruction of Digital Image

ABSTRACT

The present invention is related to a system and method that provides 100% numerically lossless reconstruction of the image as compared from its uncompressed source. The method of the present invention is configured to compress the raw Red-Green-Blue (RGB) data from a digital image stored on a device and the method further comprises the steps of compressing the pixel (P c ) only if the RGB component of the pixel (P c ) to be compressed is predictable using the RGB component of the neighboring pixels (P N ) by using the methods (m 01 -m 16 ) else the pixel (P c ) is retained.

BACKGROUND

Digital images, video technology are an essential and inherent part of the present day. Application of digital images, video technology in mobile and hand-held devices and over internet is immense. Most of the industries such as entertainment industry with animation and live action requirement, defense, broadcasting, medical imaging, surveillance, astronomy, robotics and computer graphics require soaring high on quality and performance with ever demanding needs of lossless image compression technique.

Existing professional video players provide a way to playback sequence of images or video from a compressed source which is lossy. Playing a sequence of uncompressed hi-resolution image-frames requires large RAM capacity. Commercially available hard-disk speed is not sufficient to transfer enormous amount of image data to the computer. For a 2K (2048×1024) image sequence of 800 frames, one would require 5033164800 Bytes (4.6875 GB) of RAM to playback 33.33 seconds of smooth playback at lossless quality. Hence there is a need of a system that provides lossless compression technique that allows the end user to be able to seamlessly playback video without frame-count limitations and thereby overcoming the constraint on RAM.

Hence what is needed is a compression/decompression method that provides 100% numerically lossless reconstruction of the image as compared from its uncompressed source and also the decompression system that should be extremely fast so as to read the compressed image data [and decompress] at 24 FPS losslessly.

SUMMARY

The present invention relates to a system and method for image compression and is particularly related to 100% numerically lossless reconstruction of the digital image.

The present invention relates to a system and method that provides 100% numerically lossless reconstruction of the image as compared to its uncompressed source. For this purpose, the method in accordance to one or more embodiment of the present invention compresses the pixel (P_(c)), only if the RGB component of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using any one of the methods (m₀₁-m₁₆).

In accordance to one or more embodiment of the present invention, the method that compresses the Red-Green-Blue (RGB) data from a digital image comprises the steps of identifying the pixel (P_(c)) to be compressed, identifying the neighboring pixels (P_(N)) preceding the pixel (P_(c)) to be compressed wherein the neighboring pixels (P_(N)) are taken within a cycle of four reference neighboring pixels preceding the pixel (P_(c)) to be compressed. The method further comprises the steps of checking if the RGB component of the pixel (P_(c)) to be compressed is predictable using the RGB component of the neighboring pixels (P_(N)) by using any one of the methods (m₀₁-m₁₆) and compressing the pixel (P_(c)) only if the RGB component of the pixel (P_(c)) to be compressed is predictable using the RGB component of the neighboring pixels (P_(N)) else retaining the pixel (P_(c)) if the RGB component of the pixel (P_(c)) is not predictable using the RGB component of the neighboring pixels.

In accordance to one or more embodiment of the present invention, the method of the present invention may be implemented on any personal computer, a laptop computer, a computer workstation, a server, a mainframe computer, a handheld computer, a personal digital assistant, a cellular/mobile telephone, a smart appliance, a gaming console, a digital camera, a digital camcorder, a camera phone, an iPod®, a video player, a DVD writer/player, a television and a home entertainment system.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing and other features of embodiments will become more apparent from the following detailed description of embodiments when read in conjunction with the accompanying drawings. In the drawings, like reference numerals refer to like elements.

FIG. 1 illustrates the method of identifying the neighboring pixels (P_(N)) preceding the pixel (P_(c)) to be compressed in accordance to one embodiment of the invention.

FIG. 2 illustrates the method of compressing a digital image in accordance to one embodiment of the invention.

FIG. 2 a illustrates the compression method m₀₁ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 b illustrates the compression method m₀₂ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 c illustrates the compression method m₀₃ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 d illustrates the compression method m₀₄ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 e illustrates the compression method m₀₅ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 f illustrates the compression method m₀₆ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 g illustrates the compression method m₀₇ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 h illustrates the compression method m₀₈ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 i illustrates the compression method m₀₉ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 j illustrates the compression method m₁₀ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 k illustrates the compression method m₁₁ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 l illustrates the compression method m₁₂ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 m illustrates the compression method m₁₃ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 n illustrates the compression method m₁₄ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 o illustrates the compression method m₁₅ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

FIG. 2 p illustrates the compression method m₁₆ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention.

DETAILED DESCRIPTION

The present invention overcomes the drawback of prior art by providing a system and method that provides 100% numerically lossless reconstruction of the image as compared from its uncompressed source.

The term ‘P_(c)’ is used herein to represent any pixel to be compressed and the term ‘P_(cRed), P_(cBlue) and P_(cGreen)’ is used herein to represent the Red, Green and Blue component of the pixel ‘P_(c)’ to be compressed.

The term ‘P_(N)’ is used herein to represent the neighboring pixels preceding the pixel (P_(c)) to be compressed and the neighboring pixels (P_(N)) are taken within a cycle of four reference neighboring pixels (‘P₁, P₂, P₃ and P₄’) preceding the pixel (P_(c)) to be compressed.

The term ‘P_(NRed), P_(NGreen) and P_(NBlue)’ is used herein to represent the Red, Green and Blue components of the neighboring pixel ‘P_(N)’.

The term ‘Neighbor Map’ is used herein to represent the bit wise binary representation of each neighboring pixel ‘P_(N)’ that is used for predicting the RGB component of the pixel ‘P_(C)’ to be compressed. For instance, the bit wise binary representation of (P₁, P₂, P₃ and P₄) is as follows

P₁ 00 P₂ 01 P₃ 10 P₄ 11

The term ‘P_(ind)’ is used herein to represent the index values of the neighboring pixels ‘P_(N)’. The index value of the neighboring pixels is as follows

P_(ind1) 1 P_(ind2) 2 P_(ind3) 3 P_(ind4) 4

The term ‘method map’ is used herein to represent the bit wise binary representation of method (m₀₁-m₁₆) denoting how each pixel ‘P_(c)’ is related to its neighboring pixel ‘P_(N)’. The bit wise binary representation of the methods (m01-m16) is as follows:

m01 0000 m02 0001 m03 0010 m04 0011 m05 0100 m06 0101 m07 0110 m08 0111 m09 1000 m10 1001 m11 1010 m12 1011 m13 1100 m14 1101 m15 1110 m16 1111

The term ‘component difference map’ is used herein to represent the bit wise binary representation of the difference between the RGB components of the pixel (P_(c)) to be compressed and the RGB components of the neighboring pixels (P_(N)). The bit wise binary representation of the component difference map is as follows:

D₀₁ 000 D₀₂ 000 D₀₃ 001 D₀₄ 001 D₀₅ 010 D₀₆ 010 D₀₇ 011 D₀₈ 111

The term ‘sign bit map’ is used herein to represent the bit wise binary representation of the difference between the comparisons, whether the comparison is positive or negative. If the result of the comparison is positive, the sign bit map is updated to one, else the sign bit map is updated to zero.

FIG. 1 illustrates the method of identifying the neighboring pixels (P_(N)) preceding the pixel (P_(c)) to be compressed in accordance to one embodiment of the invention. For each pixel (P_(c)) to be compressed, neighboring pixels (P_(N)) are taken within a cycle of four reference neighboring pixels preceding the pixel (P_(c)) to be compressed. As shown in FIG. 1 for each pixel (P_(c)) to be compressed, four neighboring pixels (P₁, P₂, P₃ and P₄) are identified preceding the pixel (P_(c)) to be compressed.

FIG. 2 illustrates the compression method configured for compressing a digital image in accordance to one embodiment of the present invention. The compression method for compressing a digital image acquired/stored in the device comprises the steps of identifying the RGB components of the pixel (P_(c)) to be compressed as P_(cRed), P_(cGreen) and P_(cBlue) (wherein P_(cRed) is the red component of the pixel (P_(c)) to be compressed, P_(cGreen) is the green component of the pixel (P_(c)) to be compressed and P_(cBlue) is the blue component of the pixel (P_(c)) to be compressed) in step 201, identifying the RGB components of the neighboring pixels (P_(N)) preceding the pixel (P_(c)) to be compressed as P_(NRed), P_(NGreen) and P_(NBlue) (as shown in FIG. 1, wherein P_(NRed) is the red component of the neighboring pixel of (P_(c)) to be compressed, P_(NGreen) is the green component of the neighboring pixel of (P_(c)) to be compressed and P_(NBlue) is the blue component of the neighboring pixel of (P_(c)) to be compressed,) in step 202. In step 203, checking if the RGB component of the pixel (P_(c)) to be compressed is predictable using the RGB component of the neighboring pixels (P_(N)) by using any one of the methods (m₀₁-m₁₆) (here the control is transferred to step 203 a 1 in FIG. 2 a to step 203 a 75 in FIG. 2 p to check if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using any one of the methods (m₀₁-m₁₆)) and compressing the pixel (P_(c)) in step 204 if the RGB component of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels by using any one of the methods (m₀₁-m₁₆) else retaining the pixel (P_(c)) in step 205 if the RGB component of the pixel (P_(c)) is not predictable by using any one of the methods m₀₁-m₁₆.

FIG. 2 a illustrates the compression method m₀₁ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₀₁ for compressing a digital image further comprises the steps of checking if P_(cRed)=P_(NRed) and P_(cGreen)=P_(NGreen) and P_(cblue)=P_(NBlue) and the indices of the neighboring pixels (P_(N)) are equal in step 203 a 1 (therefore only two bits is used for identifying the neighboring pixel (P_(N)) for all the RGB components that matches the condition in step 203 a 1) then updating the neighbor map with corresponding neighboring pixel (P_(N)) (binary value of the neighbor pixel (P_(N)) is added to the neighbor map), and updating the method map with method m₁₀ (binary value of method m₀₁ (0000) is added to the method map) in step 203 a 2, else transferring the control to step 203 a 3 in FIG. 2 b (here the control is transferred to step 203 a 3 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₀₂).

FIG. 2 b illustrates the compression method m₀₂ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₀₂ for compressing a digital image further comprises the steps of identifying P_(AvgRed), P_(AvgGreen), P_(AvgBlue), P_(ind) in step 203 a 3, wherein P_(AvgRed), P_(AvgGreen), P_(AvgBlue) are calculated as P_(AvgRed)=average of the red component of the neighboring pixels (P_(N)) and P_(PrevRed) (wherein P_(PrevRed) is the red component of the previous pixel of P_(N) along the horizontal scan line), P_(AvgGreen)=average of the green component of the neighboring pixels (P_(N)) and P_(PrevGreen) (wherein P_(PrevGreen) is the green component of the previous pixel of (P_(N)) along the horizontal scan-line), P_(AvgBlue)=average of the blue component of the neighboring pixels (P_(N)) and P_(PrevBlue) (wherein P_(PrevBlue) is the blue component of the previous pixel of (P_(N)) along the horizontal scan-line) and P_(ind)=index value of the neighboring pixels (P_(N)).

In step 203 a 4 checking if P_(c-Red)=P_(AvgRed)+P_(ind), P_(c-Green)=P_(AvgGreen)+P_(ind) and P_(c-Blue)=P_(AvgBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) are equal (therefore only two bits is used for identifying the neighbor pixel for all the RGB components that matches the condition in step 203 a 4) then updating the sign bit map with one (here the sign bit map is updated with one to denote the sum of the average and index value), updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₂) (binary value of method m₀₂ (0001) is added to the method map) in step 203 a 5. Else checking if P_(c-Red)=P_(AvgRed)−P_(ind), P_(c-Green)=P_(AvgGreen)−P_(ind) and P_(c-Blue)=P_(AvgBlue)−P_(ind) and the indices of the neighboring pixels (P_(N)) are equal in step 203 a 6 (therefore only two bits is used for identifying the neighbor pixel for all the RGB components that matches the condition in step 203 a 6) and if the condition holds true updating the sign bit element with zero, updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method m₀₂ (binary value of method m₀₂ (0001) is added to the method map) in step 203 a 7, else the control is transferred to step 203 a 8 in FIG. 2 c (here the control is transferred to step 203 a 8 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₀₃).

FIG. 2 c illustrates the compression method m₀₃ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₀₃ for compressing a digital image further comprises the steps of checking if P_(cRed)=P_(NRed)+P_(ind) and P_(cGreen)=P_(NGreen)+P_(ind) and P_(cBlue)=P_(NBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) are equal in step 203 a 8 (since the indices of the neighboring pixels (P_(N)) are equal, therefore only two bits is used for identifying the neighbor pixel for all the RGB components that matches the condition in step 203 a 8), then updating the sign bit map with one (here the sign bit map is updated with one to denote the sum between the RGB components of the neighboring reference pixel P_(N) and its index value), updating the neighbor map with the corresponding neighboring pixel (P_(N)), updating the method map with method 3 (m₀₃) in step 203 a 9.

If the condition as discussed in step 203 a 8 holds false then checking if P_(cRed)=P_(NRed)−P_(ind) and P_(cGreen)=P_(NGreen)−P_(ind) and P_(cBlue)=P_(NBlue)−P_(ind) and the indices of the neighboring pixels (P_(N)) are equal (therefore only two bits is used for identifying the neighbor pixel for all the RGB components that matches the condition in step 203 a 10) in step 203 a 10, then updating the sign bit map with zero (here the sign bit map is updated with zero to denote the difference between the RGB components of the neighboring reference pixel P_(N) and its index value), updating the neighbor map with the corresponding neighboring pixel (P_(N)), updating the method map with method (m₀₃) (binary value of method m₀₃ (0010) is added to the method map) in step 203 a 11. If the condition as discussed in step 203 a 10 holds false the control is transferred to step 203 a 12 in FIG. 2 d (here the control is transferred to step 203 a 12 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₀₄).

FIG. 2 d illustrates the compression method m₀₄ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method (m₀₄) for compressing a digital image further comprises the steps of identifying P_(AvgRed), P_(AvgGreen), P_(AvgBlue) in step 203 a 12 wherein P_(AvgRed)=average of the red component of the neighboring pixels (P_(N)) and P_(PrevRed) (wherein P_(PrevRed) is the red component of the previous pixel of P_(N) along the horizontal scan line), P_(AvgGreen)=average of the green component of the neighboring pixels (P_(N)) and P_(PrevGreen) (wherein P_(PrevGreen) is the green component of the previous pixel of (P_(N)) along the horizontal scan-line), P_(AvgBlue)=average of the blue component of the neighboring pixels (P_(N)) and P_(PrevBlue) (wherein P_(PrevBlue) is the blue component of the previous pixel of (P_(N)) along the horizontal scan-line).

Calculating P_(DiffRed), P_(DiffRed), P_(DiffGreen) and P_(DiffBlue) in step 203 a 13, wherein:

P _(DiffRed) =P _(NRed) −P _(PrevRed);

P _(DiffGreen) =P _(NGreen) −P _(PrevGreen);

P _(DiffBlue) =P _(NBlue) −P _(PrevBlue);

In step 203 a 14, checking if P_(CRed)=P_(AvgRed)+P_(DiffRed) and P_(cGreen)=P_(AvgGreen)+P_(DiffGreen) and P_(cBlue)=P_(AvgBlue)+P_(DiffBlue) and the indices of the neighboring pixels (P_(N)) are equal (therefore only two bits is used for identifying the neighbor pixel for all the RGB components that matches the condition in step 203 a 14) and if the condition holds true in step 203 a 14 updating the sign bit element with one (here the sign bit element is updated with one to denote the sum of the average and difference value), updating the method map with method (m04) (binary value of method m₀₄ (0011) is added to the method map) and updating the neighbor map with the corresponding neighboring pixel (P_(N)) that matches the above condition in step 203 a 15. Else if the condition holds false in step 203 a 14, checking if P_(cRed)=P_(AvgRed)−P_(DiffRed) and P_(cGreen)=P_(AvgGreen)−P_(DiffGreen) and P_(cBlue)=P_(AvgBlue)−P_(DiffBlue) and the indices of the neighboring pixels (P_(N)) are equal (therefore only two bits is used for identifying the neighbor pixel for all the RGB components that matches the condition in step 203 a 16) in step 203 a 16 and if the condition holds true in step 203 a 16 then updating the sign bit map with zero (here the sign bit element is updated with zero to denote the differences between the Average and difference value), updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₄) (binary value of method m₀₄ (0011) is added to the method map) in step 203 a 17, else the control is transferred to step 203 a 18 in FIG. 2 e (here the control is transferred to step 203 a 18 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₀₅).

FIG. 2 e illustrates the compression method m₀₅ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method (m₀₅) for compressing a digital image further comprises the steps of checking if P_(cRed)=P_(AvgRed)+P_(DiffRed)+P_(ind) and P_(cGreen)=P_(AvgGreen)+P_(DiffGreen)+P_(ind) and P_(cBlue)=P_(AvgBlue)+P_(DiffBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) are equal (therefore only two bits is used for identifying the neighboring pixel for all the RGB components that matches the condition in step 203 a 18) and if the condition holds true in step 203 a 18, updating the sign bit map with one (here the sign bit element is updated with one to denote the sum of Average, Index Value and the difference value), updating the neighbor map with the corresponding P_(N) and updating the method map with m05 (binary value of method m₀₅ (0100) is added to the method map) in step 203 a 19.

Else if the condition holds false in step 203 a 18, checking if P_(cRed)=P_(AvgRed)−P_(DiffRed)−P_(ind) and P_(cGreen)=P_(AvgGreen)−P_(DiffGreen)−P_(ind) and P_(cBlue)=P_(AvgBlue)−P_(DiffBlue)−P_(ind) and the indices of the neighboring pixels P_(N) are equal (therefore only two bits is used for identifying the neighbor pixel for all the RGB components that matches the condition in step 203 a ₂₀) in step 203 a ₂₀ and updating the sign bit map with zero (here the sign bit element is updated with zero to denote the difference between the Average, Index Value and the difference value), updating the neighbor map with the corresponding neighboring pixel P_(N) and updating the method map with method 5 (m05) (binary value of method m₀₅ (0100) is added to the method map) in step 203 a 21. Else if the condition holds false in step 203 a 20, the control is transferred to step 203 a 22 in FIG. 2 f (here the control is transferred to step 203 a 22 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₀₆).

FIG. 2 f illustrates the compression method m₀₆ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₀₆ for compressing a digital image further comprises the steps of calculating D_(NRed), D_(NGreen) and D_(NBlue) in step 203 a 22, wherein:

D _(NRed) =P _(cRed) −P _(NRed);

D _(NGreen) =P _(cGreen) −P _(NGreen);

D _(NBlue) =P _(cBlue) −P _(NBlue);

In step 203 a 23, checking if D_(NRed)=D_(NGreen) and D_(NRed)=D_(NBlue) and the value of D_(NRed) lies between 1 and 8 and if the condition in step 203 a 23 holds true then updating the sign bit map with one (here the sign bit map is updated with one to denote the difference as positive), updating the component difference map with D_(NRed), updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₆) (binary value of method m₀₆ (0101) is added to the method map) in step 203 a 24.

Else if the condition holds false in step 203 a 23, checking if D_(NRed)=D_(NGreen) and D_(NRed)=D_(NBlue) and the value of D_(NRed) lies between −1 and −8 in step 230 and if the condition holds true in step 203 a 25, updating the sign bit map with zero (here the sign bit element is updated with one to denote the difference as negative), updating the component difference map with D_(NRed), updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₆) (binary value of method m₀₆ (0101) is added to the method map) in step 203 a 26. Else if the condition holds false in step 203 a 25, the control is transferred to the step 203 a 27 in FIG. 2 g (here the control is transferred to step 203 a 27 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₀₇).

FIG. 2 g illustrates the compression method m₀₇ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₀₇ for compressing a digital image further comprises the steps of calculating D_(NRed), D_(NGreen) and D_(NBlue) in step 203 a 27, wherein:

D _(NRed) =P _(cRed) −P _(AvgRed) +P _(ind);

D _(NGreen) =P _(cGreen) −P _(AvgGreen) +P _(ind);

D _(NBlue) =P _(cBlue) −P _(AvgBlue) +P _(ind);

In step 203 a 28, checking if D_(NRed)=D_(NGreen) and D_(NRed)=D_(NBlue) and the value Of D_(NRed) lies between 1 and 8 and if the condition in step 203 a 28 holds true then updating the sign bit map with one (here the sign bit map is updated with one to denote the difference as positive), updating the component difference map with D_(NRed), updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₇), binary value of method m₀₇ (0110) is added to the method map) in step 203 a 29.

Else if the condition holds false in step 203 a 28, checking if D_(NRed)=D_(NGreen) and D_(NRed)=D_(NBlue) and the value of D_(NRed) lies between −1 and −8 in step 203 a 30 and if the condition holds true in step 203 a 30, updating the sign bit element with zero (here the sign bit element is updated with zero to denote the difference as negative), updating the component difference map with D_(NRed), updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₇) in step 203 a 31. Else if the condition holds false in step 203 a 30, then the control is transferred to the step 203 a 32 in FIG. 2 h (here the control is transferred to step 203 a 32 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₀₈).

FIG. 2 h illustrates the compression method m₀₈ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₀₈ for compressing a digital image further comprises the steps of identifying P_(PrevRed), P_(PrevGreen) and P_(PrevBlue) in step 203 a 32, wherein:

-   P_(PrevRed)=red component of the previous pixel of P_(N) along the     horizontal scan line; -   P_(PrevBlue)=blue component of the previous pixel of P_(N) along the     horizontal scan line; -   P_(PrevGreen)=green component of the previous pixel of P_(N) along     the horizontal scan line;

In step 203 a 33, checking if P_(cRed)=P_(PrevRed)+P_(ind) and P_(CGreen)=P_(PrevGreen)+P_(ind) and P_(CBlue)=P_(PrevBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) may not be equal (therefore 2 Bits for identifying each component of the neighbor pixel for each RG&B components which matches the condition in step 203 a 33), then updating the sign bit map with one (here the sign bit map is updated with one to denote the difference as positive), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)) and updating the method map with method m₀₈ (binary value of method m₀₈ (0111) is added to the method map) in step 203 a 34.

Else if the condition holds false in step 203 a 33, checking if P_(cRed)=P_(PrevRed)−P_(ind) and P_(CGreen)=P_(PrevGreen)−P_(ind) and P_(cBlue)=P_(PrevBlue)−P_(ind) and the indices of the neighboring pixels P_(N) may not be equal in step 203 a 35 (therefore 2 bits for identifying each component of the neighbor pixel for each RG&B components which matches the condition in step 203 a 35) and then updating the sign bit map with zero (here the sign bit map is updated with one to denote the difference as positive), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)) (that holds true for the condition in step 203 a 35) and updating the method map with method m08 (binary value of method m₀₈ (0111) is added to the method map) in step 203 a 36.

Else if the condition holds false in step 203 a 35, the control is transferred to the step 203 a 37 in FIG. 2 i (here the control is transferred to step 203 a 37 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₀₉).

FIG. 2 i illustrates the compression method m₀₉ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method (m₀₉) for compressing a digital image further comprises the steps of checking if P_(cRed)=P_(PrevRed)+P_(ind)+P_(DiffRed) and P_(CGreen)=P_(PrevGreen)+P_(ind)+P_(DiffGreen) and P_(CBlue)=P_(PrevBlue)+P_(ind)+P_(DiffBlue) and the indices of the neighboring pixels P_(N) may not be equal in step 203 a 37 (therefore 2 Bits for identifying each component of the neighbor pixel for each RG&B components which matches the condition in step 203 a 37) then updating the sign bit element with one (here the sign bit map is updated with one to denote the sum between Previous Pixel of the current pixel and the Index value and the sum of difference), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)) and updating the method map with method m09 (binary value of method m₀₉ (1000) is added to the method map) in step 203 a 38. Else checking if P_(cRed)=P_(PrevRed)−P_(ind)−P_(DiffRed) and P_(CGreen)=P_(PrevGreen)−P_(ind)−P_(DiffGreen) and P_(cBlue)=P_(PrevBlue)−P_(ind)−P_(DiffBlue) and the indices of neighboring pixels identifying each Red, Green and Blue component may not be equal in step 203 a 39 and updating the sign bit map with zero (here the sign bit map is updated with zero to denote the difference between Previous Pixel of the current pixel and the Index value and the sum of difference), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)) and updating the method map with method m09 (binary value of method m₀₉ (1000) is added to the method map) in step 203 a 40. Else if the condition holds false in step 203 a 39, the control is transferred to the step 203 a 41 in FIG. 2 j (here the control is transferred to step 203 a 41 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₁₀).

FIG. 2 j illustrates the compression method m₁₀ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₁₀ for compressing a digital image further comprises the steps of checking if P_(cRed)=P_(NRed)+P_(ind) and P_(CGreen)=P_(NGreen)+P_(ind) and P_(cBlue)=P_(NBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) may not be equal in step 203 a 41 (therefore 2 Bits for identifying each component of the neighbor pixel for each RG&B components which matches the condition in step 203 a 41) then updating the sign bit map with one (here the sign bit element is updated with one to denote the sum between neighboring Pixel and the Index value), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)), updating the method map with method m₁₀ (binary value of method m₁₀ (1001) is added to the method map) in step 203 a 42. Else if the condition in step 203 a 41 holds false, checking if P_(cRed)=P_(NRed)−P_(ind) and P_(cGreen)=P_(NGreen)−P_(ind) and P_(cBlue)=P_(NBlue)−P_(ind) and the indices of the neighboring pixels may not be equal in step 203 a 43 (therefore 2 Bits for identifying each component of the neighbor pixel for each RG&B components which matches the condition in step 203 a 43) then updating the sign bit element with zero (here the sign bit element is updated with zero to denote the sum between neighboring Pixel and the Index value), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)) and updating the method map with method m₁₀ (binary value of method m₁₀ (1001) is added to the method map) in step 203 a 44. If the condition holds false in step 203 a 43, the control is transferred to the step 203 a 45 in FIG. 2 k (here the control is transferred to step 203 a 45 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₁₁).

FIG. 2 k illustrates the compression method m₁₁ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method (m₁₁) for compressing a digital image further comprises the steps of identifying P_(NPrevRed), N_(PrevRed), P_(NPrevGreen) and P_(NPrevBlue) in step 203 a 45 wherein:

P _(NPrevRed) =P _((NRed−Pind));

P _(NPrevGreen) =P _((NGreen−Pind));

P _(NPrevBlue) =P _((NBlue−Pind));

In step 203 a 46, checking if P_(cRed)=P_(NPrevRed)+P_(ind) and P_(cGreen)=P_(cGreen)=P_(NPrevGreen)+P_(ind) and P_(cBlue)=P_(NPrevBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) may not be equal (therefore 2 Bits for identifying each component of the neighbor pixel for each RG&B components which matches the condition in step 203 a 46) then updating the sign bit map with one (here the sign bit map is updated with one to denote the sum between the previous pixels of the neighboring Pixel and the index value), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)) and updating the method map with method ml 1 (binary value of method m₁₁ (1010) is added to the method map) in step 203 a 47. If the condition in step 203 a 46 holds false then further checking if P_(cRed)=P_(NPrevRed)−P_(ind) and P_(CGreen)=P_(NPrevGreen)−P_(ind) and P_(cBlue)=P_(NPrevBlue)−P_(ind) and the indices of the neighboring pixels (P_(N)) may not be equal (therefore 2 Bits for identifying each component of the neighbor pixel for each RG&B components which matches the condition in step 203 a 48)in step 203 a 48 and then updating the sign bit element with zero updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)) and updating the method map with method m11 in step 203 a 49. Else transferring the control to step 203 a 50 in FIG. 2 l, (here the control is transferred to step 203 a 50 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₁₂).

FIG. 2 l illustrates the compression method m₁₂ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₁₂ for compressing a digital image further comprises the steps of identifying P_(CPrevred), P_(CPrevgreen), P_(CPrevblue) in step 203 a 50 wherein:

-   -   P_(CPrevred)=red component of the previous pixel of P_(c);     -   P_(CPrevgreen)=green component of the previous pixel of P_(c);     -   P_(CPrevblue)=blue component of the previous pixel of P_(c);

In step 203 a 51, calculating D_(CPrevDiffRed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen), wherein

D _(CPrevDiffRed) =P _(cRed) −P _(CPrevred);

D _(CPrevDiffBlue) =P _(cBlue) −P _(CPrevblue);

D _(CPrevDiffGreen) =P _(cGreen) −P _(cPrevGreen);

Checking if D_(CPrevDiffRed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen) lies between 1 and 8 in step 203 a 52 and updating the sign bit map to one (here the sign bit map is updated with one to denote the differences in step 256 is positive), updating the component difference map with D_(CPrevDiffRed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen), updating the method map with method m12 (binary value of method m₁₂ (1011) is added to the method map) in step 203 a 53. If the condition in step 203 a 52 holds false then checking if D_(CPrevDiffRed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen) lies between −1 and −8 in step 203 a 54 and then updating the updating the sign bit element to zero, updating the component difference map with D_(CPrevDiffRed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen), updating the method map with method m12 (binary value of method m₁₂ (1011) is added to the method map) in step 203 a 55 if the condition in step 203 a 54 holds true else the control is transferred to step 203 a 56 in FIG. 2 m (here the control is transferred to step 203 a 56 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₁₃).

FIG. 2 m illustrates the compression method m₁₃ of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₁₃ for compressing a digital image further comprises the steps of calculating D_(DiffRed), D_(DiffGreen) and D_(DiffBlue) in step 203 a 56, wherein:

D _(DiffRed) =P _(cRed) −P _(NRed) +P _(ind);

D _(DiffBlue) =P _(cBlue) −P _(NBlue) +P _(ind);

D _(DiffGreen) =P _(cGreen) −P _(NGreen) +P _(ind);

Checking if D_(DiffRed) and D_(DiffBlue) and D_(DiffGreen) lies between 1 and 8 in step 203 a 57 and then updating the sign bit map with one (here the sign bit map is updated with one to denote the difference in step 203 a 57 as positive), updating the component difference map with D_(DiffRed), D_(DiffBlue) and D_(DiffGreen) and updating the method map with the corresponding method m13 (binary value of method m₁₃ (1100) is added to the method map) in step 203 a 58. If the condition in step 203 a 57 holds false then further checking if D_(DiffRed) and D_(DiffBlue) and D_(DiffGreen) lies between −1 and −8 in step 203 a 59 and then updating the the sign bit element with zero (here the sign bit map is updated with zero to denote the difference in step 203 a 59 as negative), updating the component difference map with D_(DiffRed), D_(DiffBlue) and D_(DiffGreen) and updating the method map with the corresponding method m13 (binary value of method m₁₃ (1100) is added to the method map) in step 203 a 60, else transferring the control to step 203 a 61 in FIG. 2 n (here the control is transferred to step 203 a 61 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₁₄).

FIG. 2 n illustrates the compression method m14 of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₁₄ for compressing a digital image further comprises the steps of calculating D_(AvgDiffRed), D_(AvgDiffGreen) and D_(AvgDiffBlue) in step 203 a 61, wherein:

D _(AvgDiffRed) =P _(cRed) −P _(AvgRed);

D _(AvgDiffGreen) =P _(cGreen) −P _(AvgGreen);

D _(AvgDiffBlue) =P _(cBlue) −P _(AvgBlue);

In step 203 a 62, checking if D_(AvgDiffRed) and D_(AvgDiffGreen) and D_(AvgDiffBlue) lies between 1 and 8, then updating sign bit map with one (here the sign bit map is updated with one to denote the difference as positive), updating the component difference map with D_(AvgDiffRed), D_(AvgDiffGreen) and D_(AvgDiffBlue), updating the neighbor map with the corresponding P_(N), updating the method map with m14 (binary value of method m₁₄ (1101) is added to the method map) in step 203 a 63. If the condition in step 203 a 62 holds false then checking if D_(AvgDiffRed) and D_(AvgDiffGreen) and D_(AvgDiffBlue) lies between −1 and −8 in step 203 a 64 and updating sign bit map with zero (here the sign bit map is updated with zero to denote the difference as negative), updating the component difference map with D_(AvgDiffRed), D_(AvgDiffGreen) and D_(AvgDiffBlue), updating the neighbor map with the corresponding P_(N), updating the method map with m14 (binary value of method m₁₄ (1101) is added to the method map) in step 203 a 65. Else transferring the control to step 203 a 66 in FIG. 2 o (here the control is transferred to step 203 a 66 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m15).

FIG. 2 o illustrates the compression method m15 of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₁₅ for compressing a digital image further comprises the steps of calculating D_(NDiffRed), D_(NDiffGreen) and D_(NDiffBlue) in step 203 a 66, wherein:

D _(NDiffRed) =P _(cRed) −P _(NRed);

D_(NDiffGreen) =P _(cGreen) −P _(NGreen);

D _(NDiffBlue) =P _(cBlue) −P _(NBlue);

In step 203 a 67, checking if D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue) lies between 1 and 8 and then updating the sign bit map with one (here the sign bit map is updated with one to denote the difference as positive), updating the component difference map with D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)), updating the method map with method m15 (binary value of method m₁₅ (1110) is added to the method map) in step 203 a 68. If the condition holds false in step 203 a 67, checking if D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue) lies between −1 and −8 in step 203 a 69 then updating the sign bit element with zero (here the sigh bit map is updated with zero to denote the difference as positive), updating the component difference map with D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)), updating the method map with method m15 (binary value of method m₁₅ (1110) is added to the method map) in step 203 a 70. Else transferring the control to step 203 a 71 in FIG. 2 p (here the control is transferred to step 203 a 71 to check if the RGB component of the pixel P_(c) to be compressed is predictable using method m₁₆).

FIG. 2 p illustrates the compression method m16 of the present invention in detail for compressing the digital image in accordance to one embodiment of the present invention. The compression method m₁₆ for compressing a digital image further comprises the steps of calculating D_(NDiffRed), D_(NDiffGreen) and D_(NDiffBlue) in step 203 a 71 as:

D _(NDiffRed) =P _(cRed) −P _(NRed) +P _(ind);

D _(NDiffGreen) =P _(cGreen) −P _(NGreen) +P _(ind);

D _(NDiffBlue) =P _(cBlue) −P _(NBlue) +P _(ind);

Checking if D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue) lies between 1 and 8 in step 203 a 72 and updating the sign bit map with one (here the sign bit map is updated with one to denote the difference as positive), updating the component difference map with D_(NDiffRed), D_(NDiffGreen) and D_(NDiffBlue), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)) and updating the method map with method m16 (binary value of method m₁₆ (1111) is added to the method map) in step 203 a 73, if the condition in step 203 a 72 holds true. Else checking if D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue) lies between −1 and −8 in step 203 a 74 and updating the sign bit element with zero (here the sign bit map is updated with one to denote the difference as negative), updating the component difference map with D_(NDiffRed), D_(NDiffGreen) and D_(NDiffBlue), updating the neighbor map with each Red, Green and Blue component of the neighboring pixel (P_(N)), updating the method map with m16 (binary value of method m₁₆ (1111) is added to the method map) in step 203 a 75. If the condition in step 203 a 74 also holds false, then the pixel (P_(c)) is retained as shown in step 205 in FIG. 2. Else if the RGB component of the pixel (P_(c)) to be compressed is predictable using any of the above method (m₀₁-m₁₆), the pixel (P_(c)) is compressed as shown in step 204 in FIG. 2.

In accordance to one embodiment of the invention, the method also comprises the steps of tracking the method id (if method m01 is used for predicting P_(c), then the method id is 01) of P_(c) and comparing it with the method id of the previous pixel of P_(c) and updating the previous method map to one, if the method id of P_(c) and the previous pixel of P_(c) are same else the previous method map is updated to zero.

Thus the system and method of the present invention overcomes the drawback of prior art by providing 100% numerically lossless reconstruction of the image as compared from its uncompressed source. Also the system and method of the present invention may be implemented in any of the industries such as entertainment industry with animation and live action requirement, defense, broadcasting, medical imaging, surveillance, astronomy, robotics and computer graphics to allow the end users to seamlessly playback video/hi-resolution image-frames without frame-count limitations.

It is to be understood that although the invention has been described above in terms of particular embodiments, the foregoing embodiments are provided as illustrative only, and do not limit or define the scope of the invention. Various other embodiments, including but not limited to the following, are also within the scope of the claims. For example, elements and components described herein may be further divided into additional components or joined together to form fewer components for performing the same functions.

Any of the functions disclosed herein may be implemented using means for performing those functions. Such means include, but are not limited to, any of the components disclosed herein, such as the computer-related components described below.

The techniques described above may be implemented, for example, in hardware, one or more computer programs tangibly stored on one or more computer-readable media, firmware, or any combination thereof. The techniques described above may be implemented in one or more computer programs executing on (or executable by) a programmable computer including any combination of any number of the following: a processor, a storage medium readable and/or writable by the processor (including, for example, volatile and non-volatile memory and/or storage elements), an input device, and an output device. Program code may be applied to input entered using the input device to perform the functions described and to generate output using the output device.

Each computer program within the scope of the claims below may be implemented in any programming language, such as assembly language, machine language, a high-level procedural programming language, or an object-oriented programming language. The programming language may, for example, be a compiled or interpreted programming language.

Each such computer program may be implemented in a computer program product tangibly embodied in a machine-readable storage device for execution by a computer processor. Method steps of the invention may be performed by one or more computer processors executing a program tangibly embodied on a computer-readable medium to perform functions of the invention by operating on input and generating output. Suitable processors include, by way of example, both general and special purpose microprocessors. Generally, the processor receives (reads) instructions and data from a memory (such as a read-only memory and/or a random access memory) and writes (stores) instructions and data to the memory. Storage devices suitable for tangibly embodying computer program instructions and data include, for example, all forms of non-volatile memory, such as semiconductor memory devices, including EPROM, EEPROM, and flash memory devices; magnetic disks such as internal hard disks and removable disks; magneto-optical disks; and CD-ROMs. Any of the foregoing may be supplemented by, or incorporated in, specially-designed ASICs (application-specific integrated circuits) or FPGAs (Field-Programmable Gate Arrays). A computer can generally also receive (read) programs and data from, and write (store) programs and data to, a non-transitory computer-readable storage medium such as an internal disk (not shown) or a removable disk. These elements will also be found in a conventional desktop or workstation computer as well as other computers suitable for executing computer programs implementing the methods described herein, which may be used in conjunction with any digital print engine or marking engine, display monitor, or other raster output device capable of producing color or gray scale pixels on paper, film, display screen, or other output medium.

Any data disclosed herein may be implemented, for example, in one or more data structures tangibly stored on a non-transitory computer-readable medium. Embodiments of the invention may store such data in such data structure(s) and read such data from such data structure(s). 

What is claimed is:
 1. A method that compresses the raw Red-Green-Blue (RGB) data from a digital image comprises the steps of: a) identifying the pixel (P_(c)) to be compressed; b) identifying the neighboring pixels (P_(N)) preceding the pixel (P_(c)) to be compressed; c) checking if the RGB component of the pixel (P_(c)) to be compressed is predictable using the RGB component of the neighboring pixels (P_(N)); d) compressing the pixel (P_(c)) if the RGB component of the pixel (P_(c)) to be compressed is predictable using the RGB component of the neighboring pixels (P_(N)), else retaining the pixel (P_(c)) if the RGB component of the pixel (P_(c)) to be compressed is not predictable using the RGB component of the neighboring pixels (P_(N)).
 2. The method as claimed in claim 1, wherein the method provides lossless reconstruction of the image when applied to a digital image.
 3. The method as claimed in claim 1, wherein the RGB component of the pixel (P_(c)) to be compressed is predictable using the RGB component of the neighboring pixels (P_(N)) by using any one of the methods (m₀₁-m₁₆).
 4. The method as claimed in claim 1, wherein the method for predicting the RGB component of the pixel (P_(c)) to be compressed by using any one of the methods (m₀₁-m₁₆) further comprises the steps of: a) identifying the RGB components of the pixel (P_(c)) to be compressed as P_(cRed), P_(cGreen) and P_(cBlue) wherein: P_(cRed)=red component of the pixel (P_(c)) to be compressed, P_(cGreen)=green component of the pixel (P_(c)) to be compressed, P_(cBlue)=blue component of the pixel (P_(c)) to be compressed; b) identifying the RGB components of the neighboring pixels (P_(N)) to be compressed as P_(NRed), P_(NGreen) and P_(NBlue) wherein: P_(NRed)=red component of the neighboring pixel of (P_(c)) to be compressed, P_(NGreen)=green component of the neighboring pixel of (P_(c)) to be compressed, P_(NBlue)=blue component of the neighboring pixel of (P_(c)) to be compressed; c) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using the method m₀₁, wherein the method m₀₁ further comprises the steps of: checking if P_(cRed)=P_(NRed) and P_(cGreen)=P_(NGreen) and P_(cBlue)=P_(NBlue) and the indices of the neighboring pixels (P_(N)) are equal, then updating the neighbor map with corresponding neighboring pixel (P_(N)); updating the method map with the corresponding method (m₀₁), else d) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₀₂, wherein the method m₀₂ further comprises the steps of: identifying P_(AvgRed), P_(AvgGreen), P_(AvgBlue), P_(ind) wherein: P_(AvgRed)=average of the red component of the neighboring pixels (P_(N)) and P_(PrevRed), wherein P_(PrevRed) is the red component of the previous pixel of (P_(N)) along the horizontal scan line, P_(AvgGreen)=average of the green component of the neighboring pixels (P_(N)) and P_(PrevGreen), wherein P_(PrevGreen) is the green component of the previous pixel of (P_(N)) along the horizontal scanline, P_(AvgBlue)=average of the blue component of the neighboring pixels (P_(N)) and P_(PrevBlue), wherein P_(PrevBlue) is the blue component of the previous pixel of (P_(N)) along the horizontal scanline, P_(ind)=index value of the neighboring pixels (P_(N)); checking if P_(cRed)=P_(AvgRed)+P_(ind), P_(cGreen)=P_(AvgGreen)+P_(ind) and P_(cBlue)=P_(AvgBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) are equal; then updating the sign bit map with one; updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₂), else checking if P_(cRed)=P_(AvgRed)−P_(ind), P_(c-Green)=P_(AvgGreen)−P_(ind) and P_(c-Blue)=P_(AvgBlue)−P_(ind) and the indices of the neighboring pixels (P_(N)) are equal; then updating the sign bit map with zero; updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₂); else e) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₀₃, wherein the method m₀₃ further comprises the steps of: checking if P_(cRed)=P_(NRed)+P_(ind) and P_(cGreen)=P_(NGreen)+P_(ind) and P_(cBlue)=P_(NBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) are equal, then updating the sign bit map with one; updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₃), else checking if P_(cRed)=P_(NRed)−P_(ind) and P_(cGreen)=P_(NGreen)−P_(ind) and P_(cBlue)=P_(NBlue)−P_(ind) and the indices of the neighboring pixels (P_(N)) are equal; then updating the sign bit map with zero; updating the method map with method (m₀₃) and updating the neighbor map with the corresponding neighboring pixel (P_(N)), else f) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₀₄, wherein the method m₀₄ further comprises the steps of: identifying P_(AvgRed), P_(AvgGreen), P_(AvgBlue); calculating P_(DiffRed), P_(DiffGreen) and P_(DiffBlue), wherein: P _(DiffRed) =P _(NRed) −P _(prevRed), P _(DiffGreen) =P _(NGreen) −P _(prevGreen), P _(DiffBlue) =P _(NBlue) −P _(PrevBlue); checking if P_(cRed)=P_(AvgRed)+P_(DiffRed) and P_(cGreen)=P_(AvgGreen)+P_(DiffGreen) and P_(cBlue)=P_(AvgBlue)+P_(DiffBlue) and the indices of the neighboring pixels (P_(N)) are equal; then updating the sign bit map with one; updating the method map with method (m04) and updating the neighbor map with the corresponding neighboring pixel (P_(N)), else checking if P_(cRed)=P_(AvgRed)−P_(DiffRed) and P_(cGreen)=P_(AvgGreen)−P_(DiffGreen) and P_(cBlue)=P_(AvgBlue)−P_(DiffBlue) and the indices of the neighboring pixels (P_(N)) are equal; then updating the sign bit map with zero; updating the method map with method (m04) and updating the neighbor map with the corresponding neighboring pixel (P_(N)); g) else checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₀₅, wherein the method m₀₅ further comprises the steps of: checking if P_(cRed)=P_(AvgRed)+P_(DiffRed)+P_(ind) and P_(cGreen)=P_(AvgGreen)+P_(DiffGreen)+P_(ind) and P_(cBlue)=P_(AvgBlue)+P_(DiffBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) are equal; then updating the sign bit map with one; updating the method map with method (m₀₅); updating the neighbor map with the corresponding neighboring pixel (P_(N)), else checking if P_(cRed)=P_(AvgRed)−P_(DiffRed)−P_(ind) and P_(cGreen)=P_(AvgGreen)−P_(DiffGreen)−P_(ind) and P_(cBlue)=P_(AvgBlue)−P_(DiffBlue)−P_(ind) and the indices of neighboring pixels (P_(N)) are equal, then updating the sign bit map with zero; updating the method map with method (m₀₅) and updating the neighbor map with the corresponding neighboring pixel (P_(N)); h) else checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₀₆, wherein the method m₀₆ further comprises the steps of: calculating D_(NRed), D_(NGreen) and D_(NBlue), wherein: ti D _(NRed) =P _(cRed) −P _(NRed), D _(NGreen) =P _(cGreen) −P _(NGreen), D _(NBlue) =P _(cBlue) −P _(NBlue); checking if D_(NRed)=D_(NGreen) and D_(NRed)=D_(NBlue) and the value of D_(NRed) lies between 1 and 8; then updating the sign bit map with one; updating the component difference map with D_(NRed); updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₆), else checking if D_(NRed)=D_(NGreen) and D_(NRed)=D_(NBlue) and the value of D_(NRed) lies between −1 and −8; then updating the sign bit map with zero; updating the component difference map with D_(NRed); updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m06), else i) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₀₇, wherein the method m₀₇ comprises the steps of: calculating D_(NRed), D_(NGreen) and D_(NBlue) wherein: D _(NRed) =P _(cRed) −P _(AvgRed) +P _(ind), D _(NGreen) =P _(cGreen) −P _(AvgGreen) +P _(ind), D _(NBlue) =P _(cBlue) −P _(AvgBlue) +P _(ind); checking if D_(NRed)=D_(NGreen) and D_(NRed)=D_(NBlue) and the value of D_(NRed) lies between 1 and 8; updating the sign bit map with one; updating the component difference map with D_(NRed); updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m₀₇); or else checking if D_(NRed)=D_(NGreen) and D_(NRed)=D_(NBlue) and the value of D_(NRed) lies between −1 and −8; updating the sign bit map with zero; updating the component difference map with D_(NRed); updating the neighbor map with the corresponding neighboring pixel (P_(N)) and updating the method map with method (m07), else j) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₀₈, wherein the method m₀₈ further comprises the steps of: identifying P_(PrevRed), P_(PrevGreen) and P_(PrevBlue) wherein: P_(PrevRed)=red component of the previous pixel of P_(N) along the horizontal scanline, P_(PrevGreen)=green component of the previous pixel of P_(N) along the horizontal scanline, P_(PrevBlue)=blue component of the previous pixel of P_(N) along the horizontal scanline; checking if P_(cRed)=P_(PrevRed)+P_(ind) and P_(cGreen)=P_(PrevGreen)+P_(ind) and P_(cBlue)=P_(PrevBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) are not equal; then updating the sign bit map with one; updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m₀₈, else checking if P_(cRed)=P_(PrevRed)−P_(ind) and P_(cGreen)=P_(PrevGreen)−P_(ind) and P_(cBlue)=P_(PrevBlue)−P_(ind) and the indices of the neighboring pixels (P_(N)) are not equal; updating the sign bit map with zero; updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m08, else k) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₀₉, wherein the method m₀₉ further comprises the steps of: checking if P_(cRed)=P_(PrevRed)+P_(ind)+P_(DiffRed) and P_(cGreen)=P_(PrevGreen)+P_(ind)+P_(DiffGreen) and P_(cBlue)=P_(PrevBlue)+P_(ind)+P_(DiffBlue) and the indices of the neighboring pixels (P_(N)) are not equal then; updating the sign bit map with one; updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m09; or else checking if P_(cRed)=P_(PrevRed)=P_(ind)−P_(DiffRed) and P_(cGreen)=P_(PrevGreen)−P_(ind)−P_(DiffGreen) and P_(cBlue)=P_(PrevBlue)−P_(ind)−P_(DiffBlue) and the indices of the neighboring pixels (P_(N)) are not equal then; updating the sign bit map with zero; updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m09; else l) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₁₀, wherein the method m₁₀ further comprises the steps of: checking if P_(cRed)=P_(NRed)−P_(ind) and P_(cGreen)=P_(NGreen)+P_(ind) and P_(cBlue)=P_(NBlue) P_(ind) and the indices of the neighboring pixels (P_(N)) are not equal then; updating the sign bit map with one; updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m₁₀, or else checking if P_(cRed)=P_(NRed)−P_(ind) and P_(cGreen)=P_(NGreen)−P_(ind) and P_(cBlue)=P_(NBlue)−P_(ind) and the indices of the neighboring pixels (P_(N)) are not equal then; updating the sign bit map with zero; updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m10, else m) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₁₂, wherein the method m₁₁ further comprises the steps of: identifying P_(NPrevRed), P_(NPrevGreen) and P_(NPrevBlue) wherein: P _(NPrevRed) =P _((NRed−Pind)), P _(NPrevGreen) =P _((NGreen−Pind)), P _(NPrevBlue) =P _((NBlue−Pind)); checking if P_(cRed)=P_(NPrevRed)+P_(ind) and P_(cGreen)=P_(NPrevGreen)+P_(ind) and P_(cBlue)=P_(NPrevBlue)+P_(ind) and the indices of the neighboring pixels (P_(N)) are not equal then; updating the sign bit map with one; updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m11, else checking if P_(cRed)=P_(NPrevRed)−P_(ind) and P_(CGreen)=P_(NPrevGreen)−P_(ind) and P_(cBlue)=P_(NPrevBlue)−P_(ind) and the indices of the neighboring pixels (P_(N)) are not equal then; updating the sign bit map with zero; updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m11; else n) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₁₂, wherein the method m₁₂ further comprises the steps of: identifying P_(CPrevred), P_(CPrevgreen), P_(CPrevblue), wherein: P_(CPrevred)=red component of the previous pixel of P_(c), P_(CPrevgreen)=green component of the previous pixel of P_(c), P_(CPrevblue)=blue component of the previous pixel of P_(c); calculating D_(CPrevDiffRed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen) wherein: D _(CPrevDiffRed) =P _(cRed) −P _(CPrevred), D _(CPrevDiffBlue) =P _(cBlue) −P _(CPrevblue), D _(CPrevDiffGreen) =P _(cGreen) −P _(cPrevGreen); checking if D_(CPrevDiffRed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen) lies between 1 and 8; then updating the sign bit map with one; updating the component difference map with D_(CPrevDiffRed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen); updating the method map with method m12, or else checking if D_(CPrevDiffRed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen) lies between −1 and −8 then updating the sign bit map with zero; updating the component difference map with D_(CPrevDifed), D_(CPrevDiffBlue) and D_(CPrevDiffGreen); updating the method map with method m12, else o) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method M₁₃, wherein the method m₁₃ further comprises the steps of: calculating D_(DiffRed), D_(DiffGreen) and D_(DiffBlue), wherein: D _(DiffRed) =P _(cRed) −P _(NRed) +P _(ind), D _(DiffBlue) =P _(cBlue) −P _(NBlue) +P _(ind), D _(DiffGreen) =P _(cGreen) −P _(NGreen) +P _(ind); checking if D_(DiffRed), D_(DiffBlue) and D_(DiffGreen) lies between 1 and 8; updating the sign bit map with one; updating the component difference map with D_(DiffRed), D_(DiffBlue) and D_(DiffGreen); updating the neighbor map with the corresponding neighbor pixel (P_(N)); updating the method map with the corresponding method m13, else checking if D_(DiffRed), D_(DiffBlue) and D_(DiffGreen) lies between −1 and −8; updating the sign bit element with zero; updating the component difference map with D_(DiffRed), D_(DiffBlue) and D_(DiffGreen); updating the neighbor map with the corresponding neighbor pixel (P_(N)); updating the method map with the corresponding method m13, else p) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₁₄, wherein the method m₁₄ further comprises the steps of: calculating D_(AvgDiffRed), D_(AvgDiffGreen) and D_(AvgDiffBlue), wherein: D _(AvgDiffRed) =P _(cRed) −P _(AvgRed), D _(AvgDiffGreen) =P _(cGreen) −P _(AvgGreen), D _(AvgDiffBlue) =P _(cBlue) −P _(AvgBlue); checking if D_(AvgDiffRed) and D_(AvgDiffGreen) and D_(AvgDiffBlue) lies between 1 and 8; updating the sign bit map with one; updating the component difference map with D_(AvgDiffRed), D_(AvgDiffGreen) and D_(AvgDiffBlue); updating the neighbor map with the corresponding neighboring pixel (P_(N)); updating the method map with method m14, else checking if D_(AvgDiffRed) and D_(AvgDiffGreen) and D_(AvgDiffBlue) lies between −1 and −8; updating the sign bit element with zero; updating the component difference map with D_(AvgDiffRed), D_(AvgDiffGreen) and D_(AvgDiffBlue); updating the neighbor map with corresponding neighboring pixel (P_(N)); updating the method map with method m14, else q) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₁₅, wherein the method m₁₅ further comprises the steps of: calculating D_(NDiffRed), D_(NDiffGreen) and D_(NDiffBlue), wherein: D _(NDiffRed) =P _(cRed) −P _(NRed), D _(NDiffGreen) =P _(cGreen) −P _(NGreen), D _(NDiffBlue) =P _(cBlue) −P _(NBlue); checking if D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue) lies between 1 and 8; updating the sign bit map with one; updating the component difference map with D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue); updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m15; or else checking if D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue) lies between −1 and −8; updating the sign bit map with zero; updating the component difference map with D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue); updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method m15, else r) checking if the RGB components of the pixel (P_(c)) to be compressed is predictable using the RGB components of the neighboring pixels (P_(N)) by using method m₁₆, wherein the method m₁₆ further comprises the steps of: calculating D_(NDiffRed), D_(NDiffGreen) and D_(NDiffBlue) as: D _(NDiffRed) =P _(cRed) −P _(NRed) +P _(ind), D _(NDiffGreen) =P _(cGreen) −P _(NGreen) +P _(ind), D _(NDiffBlue) =P _(cBlue) −P _(NBlue) +P _(ind); checking if D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue) lies between 1 and 8; updating the sign bit map with one; updating the component difference map with D_(NDiffRed), D_(NDiffGreen) and D_(NDiffBlue); updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method (m16), else checking if D_(NDiffRed) and D_(NDiffGreen) and D_(NDiffBlue) lies between −1 and −8; updating the sign bit element with zero; updating the component difference map with D_(NDiffRed), D_(NDiffGreen) and D_(NDiffBlue); updating the neighbor map with the corresponding neighboring pixel (P_(N)) for each Red, Green and Blue component; updating the method map with method (m16).
 5. The method as claimed in claim 4, wherein the method further comprises the steps of updating the compression map with one, if the RGB component of the pixel (P_(c)) to be compressed is predictable using any one of the methods (m₀₁-m₁₆), else updating the compression map with zero.
 6. The method as claimed in claim 4, wherein the neighboring pixels (P_(N)) are taken within a cycle of four reference neighboring pixels preceding the pixel (P_(c)) to be compressed.
 7. The method as claimed in claim 4, wherein the neighbor map is the bit wise binary representation of each neighboring pixel ‘P_(N)’ that is used for predicting the RGB component of the pixel ‘P_(c)’ to be compressed.
 8. The method as claimed in claim 4, wherein the method map is the bit wise binary representation of method (m₀₁-m₁₆) denoting how each pixel P_(c) to be compressed is related to its neighboring pixel ‘P_(N)’.
 9. The method as claimed in claim 4, wherein the sign bit map is the bit wise binary representation of the difference between the comparisons used in method (m₀₁-m₁₆).
 10. The device as claimed in claim 4, wherein the component difference map is the bit wise binary representation of the difference between the RGB components of the pixel (P_(c)) to be compressed and the RGB components of the neighboring pixels (P_(N)).
 11. The method as claimed in claim 1, wherein the method is implemented in a personal computer, a laptop computer, a computer workstation, a server, a mainframe computer, a handheld computer, a personal digital assistant, a cellular/mobile telephone, a smart appliance, a gaming console, a digital camera, a digital camcorder, a camera phone, a iPod®, a video player, a DVD writer/player, a television or a home entertainment system. 